/* 过滤识别的文字，生成对应的题目
因为OCR文字识别接口，只能识别出来每一行对应的文字，不能将题目做更多解释
所以需要对返回的数据进行手动解释 */

let question_type; // 题目类型
const optArr = ['A', 'B', 'C', 'D'];

// 类型判断，目前暂时设定为 选择、判断、填空、简答、其他
const typeConfirm = (textArr) => {
    try {
        let newOptArr = []; // 与optArr做比较
        let type; // 除选择外的其他类型
        // 遍历数组
        textArr.forEach((line, lineIndex) => {
            const { words } = line;
            // 选择题的判定方法，同时包含ABCD为首开头的选项，并且是按照顺序的
            optArr.forEach((opt) => {
                // 如果识别记录的同时包含，以ABCD为首字母的不同行
                if (words.indexOf(opt) === 0 && words.slice(0, 2) === opt + '、') {
                    newOptArr.push(opt)
                }
            });
            /* 判断题的判定方法，题型和接口限制，此处直接根据首行提示；
            同填空，同简单题
             */
            if (lineIndex === 0) {
                // 直接提示题目类型
                type = line.words;
            }
        })

        if (JSON.stringify(newOptArr) === JSON.stringify(optArr) || type.includes('选择题')) {
            // 如果满足条件，类型为choice
            question_type = 'choice';
        } else if (type.includes('判断题')) {
            question_type = 'judgment';
        } else if (type.includes('填空题')) {
            question_type = 'fill';
        } else if (type.includes('简答题')) {
            question_type = 'explain';
        } else {
            // 未能识别出来规定的类型，划分区域为其他
            question_type = 'null'
        }

    } catch (error) {
        console.log('抱歉，该图片识别出是未知的题题目类型');
    }
}

// 封装函数，本行内容不仅仅是一行，多行的情况，仅限于多行字符串，段落
const outManyLine = (arr, value) => {
    if (arr.length === 1) {
        // 只有一个字段，无需合并
        value = arr[0].words;
    } else {
        // 多个字段，需要合并
        let str = '';
        arr.forEach((obj) => {
            str += str + obj.words;
        })
        value = str;
    }
    return value; // 返回处理过的值
}

// 分析OCR文字识别的结果
const useFilterText = (textArr) => {
    let textFilterResultObj = {}; // 要返回处理成功的对象
    let title; // 题目，类型为选择时需要额外考虑，第一行内容是否必须
    let answer; // 正确答案


        console.log('需要过滤的文字', !textArr,Array.isArray(textArr),textArr);
        // 传入的文字，为false，抛出错误
     
            // 题目类型判定
            typeConfirm(textArr);
            console.log('question_type', question_type);

            // 获取正确答案
            let answerIndex; // 正确答案开始的下标
            textArr.forEach((line, lineIndex) => {
                const { words } = line;
                if (words.indexOf('答案') === 0) {
                    answerIndex = lineIndex;
                    answer = line.words.split('：')[1]; // 遵守格式
                }
            })

            /* 情况一，结果为选择题 type：choice
            统一制定：以选项A为分界，前面全部为题目描述，后面为选项
            选项只考虑option分四行的情况，暂不考虑两个option同行
            */
            if (question_type === 'choice') {
                let optIndexArr = []; // 四个选项开始的下标
                let optEndIndex; // 最后一个选项 D，结束的下标
                textArr.forEach((line, lineIndex) => {
                    const { words } = line;
                    optArr.forEach((opt) => {
                        if (words.indexOf(opt) === 0 && words.slice(0, 2) === opt + '、') {
                            optIndexArr.push(lineIndex);
                        }
                    })
                });
                let titArr; // 包含标题的数组
                if (textArr[0].words.includes('选择题')) {
                    // 题目字段 title，从第二行开始，到A选项这一行结束
                    titArr = textArr.slice(1, optIndexArr[0]);
                } else {
                    //  题目字段，从第一行开始，到A这一行结束
                    titArr = textArr.slice(0, optIndexArr[0]);
                }
                //  输出题目标题
                title = outManyLine(titArr, title);

                // optIndexArr 包含四个元素，为四个选项的起始行
                // 因为第四个选项，考虑到后一行《正确答案》的影响，一次四个选项分开来赋值
                const singeOptArr_a = textArr.slice(optIndexArr[0], optIndexArr[1]);
                const singeOptArr_b = textArr.slice(optIndexArr[1], optIndexArr[2]);
                const singeOptArr_c = textArr.slice(optIndexArr[2], optIndexArr[3]);
                const singeOptArr_d = textArr.slice(optIndexArr[3], answerIndex);
                // 输出选项，一个选项分为一行或多行的情况
                let cent_a = outManyLine(singeOptArr_a, cent_a); // A 选项的内容
                let cent_b = outManyLine(singeOptArr_b, cent_b); // B 选项的内容
                let cent_c = outManyLine(singeOptArr_c, cent_c); // C 选项的内容
                let cent_d = outManyLine(singeOptArr_d, cent_d); // D 选项的内容
                // 把选项存放在数组里
                let optionArr = [
                    { opt: 'A', cent: cent_a.slice(2) },
                    { opt: 'B', cent: cent_b.slice(2) },
                    { opt: 'C', cent: cent_c.slice(2) },
                    { opt: 'D', cent: cent_d.slice(2) }
                ];

                // 生成符合录入数据库的选项数据
                textFilterResultObj.option = optionArr;
            }

            //    情况二：结果为判断题 type：judgment
            else if (question_type === 'judgment' || question_type === 'fill' || question_type === 'explain') {
                let titArr = textArr.slice(1, answerIndex);
                // 输出题目的标题
                title = outManyLine(titArr, title);
            }

            else if (question_type === 'null') {
                let titArr = textArr.slice(0, answerIndex);
                // 输出题目的标题
                title = outManyLine(titArr, title);
            }

            // 题目识别处理，题目不需要序号
            const titRegNum = /^[0-9]*$/; // 验证数字的正则
            if (titRegNum.test(title.slice(0, 1))) {
                // 如果题目开头第一位是数字，几位数字未知，不需要序号
                let charIndexArr = [];
                // 找到所有的 .
                for (let char of title) {
                    if (char === '.') {
                        charIndexArr.push(title.indexOf(char));
                    }
                }
                const arrarMin = Function.prototype.apply.bind(Math.min, null);
                title = title.slice(arrarMin(charIndexArr) + 1);
            };
            textFilterResultObj.title = title;
            textFilterResultObj.answer = answer;
            textFilterResultObj.question_type = question_type;

            return textFilterResultObj;

       
}

export default useFilterText;